Node.js ES6+ Features

நவீன JavaScript அம்சங்களைப் பயன்படுத்தி சுத்தமான மற்றும் சக்திவாய்ந்த குறியீடுகளை எழுத கற்றுக்கொள்ளுங்கள்

ES6+ என்றால் என்ன?

ES6 (ECMAScript 2015) மற்றும் பிற பதிப்புகள் JavaScript க்கு சக்திவாய்ந்த புதிய அம்சங்களைச் சேர்க்கின்றன, இது உங்கள் குறியீட்டை மிகவும் வெளிப்படையான, சுருக்கமான மற்றும் பாதுகாப்பானதாக ஆக்குகிறது.

Node.js நவீன JavaScript அம்சங்களுக்கு சிறந்த ஆதரவைக் கொண்டுள்ளது.

Node.js பொருந்தக்கூடிய தன்மை

அனைத்து நவீன Node.js பதிப்புகளும் (10+) ES6+ அம்சங்களுக்கு சிறந்த ஆதரவைக் கொண்டுள்ளன

புதிய அம்சங்கள்

புதிய பதிப்புகள் ES2020 மற்றும் அதற்கு மேற்பட்டவற்றிலிருந்து இன்னும் அண்மைய JavaScript சேர்ப்புகளை ஆதரிக்கின்றன

நன்மைகள்

இந்த நவீன JavaScript அம்சங்கள் உங்களுக்கு உதவுகின்றன:

let மற்றும் const

மாறிகளை அறிவிக்க விருப்பமான வழியாக var ஐ let மற்றும் const முக்கிய வார்த்தைகள் மாற்றியமைத்தன:

எடுத்துக்காட்டு: let மற்றும் const

// Using let (can be changed)
let score = 10;
score = 20;
// Using const (cannot be reassigned)
const MAX_USERS = 100;

// Block scope with let
if (true) {
  let message = 'Hello';
  console.log(message); // Works here
}

அம்புக்குறி செயல்பாடுகள்

அம்புக்குறி செயல்பாடுகள் செயல்பாடுகளை எழுதுவதற்கான ஒரு சுருக்கமான தொடரியலை வழங்குகின்றன மற்றும் சூழ்ந்துள்ள சூழலுக்கு this ஐ தானாகவே பிணைக்கின்றன.

அம்புக்குறி செயல்பாடுகளின் முக்கிய நன்மைகள்:

எடுத்துக்காட்டு: அம்புக்குறி செயல்பாடுகள்

// Traditional function
function add(a, b) {
  return a + b;
}

// Arrow function (same as above)
const addArrow = (a, b) => a + b;

// Single parameter (no parentheses needed)
const double = num => num * 2;

// No parameters (parentheses needed)
const sayHello = () => 'Hello!';

// Using with array methods
const numbers = [1, 2, 3];
const doubled = numbers.map(num => num * 2);
console.log(doubled);

⚠️ அம்புக்குறி செயல்பாடுகளை எப்போது பயன்படுத்தக்கூடாது:

  • பொருள் முறைகள் (இதில் `this` பொருளைக் குறிப்பிட வேண்டும்)
  • கன்ஸ்ட்ரக்டர் செயல்பாடுகள் (அம்புக்குறி செயல்பாடுகள் `new` உடன் பயன்படுத்த முடியாது)
  • `this` உறுப்பைக் குறிப்பிட வேண்டிய நிகழ்வு கையாளுநர்கள்

டெம்ப்ளேட் லிட்டரல்கள்

டெம்ப்ளேட் லிட்டரல்கள் (டெம்ப்ளேட் சரங்கள்) பேக்டிக்ஸ் (`) பயன்படுத்தி உட்பொதிக்கப்பட்ட வெளிப்பாடுகளுடன் சரங்களை உருவாக்க ஒரு நேர்த்தியான வழியை வழங்குகின்றன.

டெம்ப்ளேட் லிட்டரல்களின் முக்கிய அம்சங்கள்:

எடுத்துக்காட்டு: டெம்ப்ளேட் லிட்டரல்கள்

// Basic string interpolation
const name = 'Alice';
console.log(`Hello, ${name}!`);

// Multi-line string
const message = `
  This is a multi-line
  string in JavaScript.
`;
console.log(message);

// Simple expression
const price = 10;
const tax = 0.2;
console.log(`Total: $${price * (1 + tax)}`);

டீஸ்ட்ரக்சரிங்

டீஸ்ட்ரக்சரிங் வரிசைகளிலிருந்து மதிப்புகளை அல்லது பொருள்களிலிருந்து பண்புகளை ஒரு சுருக்கமான தொடரியலுடன் தனித்த மாறிகளில் பிரித்தெடுக்க உங்களை அனுமதிக்கிறது.

டீஸ்ட்ரக்சரிங்கின் முக்கிய அம்சங்கள்:

எடுத்துக்காட்டு: பொருள் டீஸ்ட்ரக்சரிங்

// Basic object destructuring
const user = { name: 'Alice', age: 30, location: 'New York' };
const { name, age } = user;
console.log(name, age);

எடுத்துக்காட்டு: வரிசை டீஸ்ட்ரக்சரிங்

// Basic array destructuring
const colors = ['red', 'green', 'blue'];
const [first, second, third] = colors;
console.log(first, second, third);

// Skipping elements
const [primary, , tertiary] = colors;
console.log(primary, tertiary);

ஸ்ப்ரெட் மற்றும் ரெஸ்ட் ஆபரேட்டர்கள்

ஸ்ப்ரெட் மற்றும் ரெஸ்ட் ஆபரேட்டர்கள் (இரண்டும் ... என எழுதப்பட்டவை) பல உறுப்புகளுடன் திறம்பட வேலை செய்ய உங்களை அனுமதிக்கின்றன.

எடுத்துக்காட்டு: ஸ்ப்ரெட் ஆபரேட்டர்

// Array spread - combining arrays
const numbers = [1, 2, 3];
const moreNumbers = [4, 5, 6];
const combined = [...numbers, ...moreNumbers];
console.log(combined);

// Array spread - converting string to array of characters
const chars = [...'hello'];
console.log(chars);

எடுத்துக்காட்டு: ரெஸ்ட் ஆபரேட்டர்

// Rest parameter in functions
function sum(...numbers) {
  return numbers.reduce((total, num) => total + num, 0);
}
console.log(sum(1, 2, 3, 4, 5));

இயல்புநிலை அளவுருக்கள்

ES6+ செயல்பாடு அளவுருக்களுக்கு இயல்புநிலை மதிப்புகளைக் குறிப்பிட உங்களை அனுமதிக்கிறது, பல நிகழ்வுகளில் கையேடு அளவுரு சரிபார்ப்பின் தேவையை நீக்குகிறது.

இயல்புநிலை அளவுருக்களின் முக்கிய நன்மைகள்:

எடுத்துக்காட்டு: இயல்புநிலை அளவுருக்கள்

// Basic default parameter
function greet(name = 'Guest') {
  return `Hello, ${name}!`;
}

console.log(greet());
console.log(greet('Kai'));

வகுப்புகள்

ES6 JavaScript க்கு வகுப்பு தொடரியலை அறிமுகப்படுத்தியது, இது பொருள்களை உருவாக்கவும் மரபுரிமையை செயல்படுத்தவும் தெளிவான மற்றும் மிகவும் சுருக்கமான வழியை வழங்குகிறது.

தொழில்நுட்ப ரீதியாக, JavaScript வகுப்புகள் இன்னும் புரோட்டோடைப்புகளை அடிப்படையாகக் கொண்டவை.

JavaScript வகுப்புகளின் முக்கிய அம்சங்கள்:

எடுத்துக்காட்டு: வகுப்பு அடிப்படைகள்

// Simple class with constructor and method
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    return `Hello, I'm ${this.name}!`;
  }
}

// Create an instance
const person = new Person('Alice', 25);
console.log(person.greet()); // Hello, I'm Alice!

எடுத்துக்காட்டு: வகுப்பு மரபுரிமை

// Parent class
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    return `${this.name} makes a sound.`;
  }
}

// Child class
class Dog extends Animal {
  speak() {
    return `${this.name} barks!`;
  }
}

const dog = new Dog('Rex');
console.log(dog.speak());

எடுத்துக்காட்டு: தனியார் வகுப்பு புலங்கள் (ES2022+)

// Class with private field (# prefix)
class Counter {
  #count = 0; // Private field

  increment() {
    this.#count++;
  }

  getCount() {
    return this.#count;
  }
}

const counter = new Counter();
counter.increment();
console.log(counter.getCount());
// console.log(counter.#count); // Error: Private field

வாக்குறுதிகள் மற்றும் Async/Await

நவீன JavaScript தாமதங்கள், API அழைப்புகள் அல்லது I/O செயல்பாடுகளை உள்ளடக்கிய குறியீட்டுடன் வேலை செய்வதை மிகவும் எளிதாக்கும் அசிங்க்ரோனஸ் செயல்பாடுகளைக் கையாள சக்திவாய்ந்த கருவிகளை வழங்குகிறது.

வாக்குறுதிகள்

வாக்குறுதிகள் இன்னும் கிடைக்காத மதிப்புகளைக் குறிக்கின்றன.

அவை கால்பேக்குகளுடன் ஒப்பிடும்போது அசிங்க்ரோனஸ் செயல்பாடுகளைக் கையாள மிகவும் நேர்த்தியான வழியை வழங்குகின்றன.

ஒரு வாக்குறுதி இந்த நிலைகளில் ஒன்றில் உள்ளது:

எடுத்துக்காட்டு: அடிப்படை வாக்குறுதிகள்

// Creating a promise
const fetchData = () => {
  return new Promise((resolve, reject) => {
     // Simulating an API call
     setTimeout(() => {
       const data = { id: 1, name: 'Product' };
       const success = true;

       if (success) {
         resolve(data); // Fulfilled with data
       } else {
         reject(new Error('Failed to fetch data')); // Rejected with error
       }
     }, 1000);
  });
};

// Using a promise
console.log('Fetching data...');

fetchData()
  .then(data => {
    console.log('Data received:', data);
    return data.id; // Return value is passed to the next .then()
  })
  .then(id => {
    console.log('Processing ID:', id);
  })
  .catch(error => {
    console.error('Error:', error.message);
  })
  .finally(() => {
    console.log('Operation completed (success or failure)');
  });

console.log('Continuing execution while fetch happens in background');

Async/Await

Async/await (ES2017 இல் அறிமுகப்படுத்தப்பட்டது) வாக்குறுதிகளுடன் வேலை செய்வதற்கான ஒரு சுத்தமான தொடரியலை வழங்குகிறது, அசிங்க்ரோனஸ் குறியீடு ஒத்திசைவான குறியீட்டைப் போல தோற்றமளிக்கவும் நடந்துகொள்ளவும் செய்கிறது.

எடுத்துக்காட்டு: Async/Await

// Function that returns a promise
const fetchUser = (id) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (id > 0) {
        resolve({ id, name: `User ${id}` });
       } else {
        reject(new Error('Invalid user ID'));
       }
     }, 1000);
  });
};

// Using async/await
async function getUserData(id) {
  try {
    console.log('Fetching user...');
    const user = await fetchUser(id); // Waits for the promise to resolve
    console.log('User data:', user);

    // You can use the result directly
    return `${user.name}'s profile`;
  } catch (error) {
     // Handle errors with try/catch
     console.error('Error fetching user:', error.message);
     return 'Guest profile';
   }
}

// Async functions always return promises
console.log('Starting...');
getUserData(1)
  .then(result => console.log('Result:', result))
  .catch(error => console.error('Unexpected error:', error));
console.log('This runs before getUserData completes');

⚠️ பொதுவான Async/Await தவறுகள்:

  • Async செயல்பாடுகள் எப்போதும் வாக்குறுதிகளை வழங்குகின்றன என்பதை மறந்துவிடுதல்
  • try/catch உடன் பிழைகளைக் கையாளத் தவறுதல்
  • இணையாக இயக்க முடியும் போது தொடர்ச்சியாக செயல்பாடுகளை இயக்குதல்
  • Async செயல்பாட்டிற்கு வெளியே await பயன்படுத்துதல்
  • வாக்குறுதி அல்லாத மதிப்புகளை எதிர்பார்த்திருப்பது (தேவையற்றது ஆனால் தீங்கற்றது)

ES தொகுதிகள்

ES தொகுதிகள் (ESM) குறியீட்டை ஒழுங்கமைக்க மற்றும் பகிர்ந்து கொள்ள ஒரு தரப்படுத்தப்பட்ட வழியை வழங்குகின்றன. அவை ES2015 இல் அறிமுகப்படுத்தப்பட்டன மற்றும் இப்போது Node.js இல் உள்ளூர்ப் படிவத்தில் ஆதரிக்கப்படுகின்றன.

ES தொகுதிகளின் முக்கிய நன்மைகள்:

எடுத்துக்காட்டு: ES தொகுதிகள்

File: math.js

// Named exports
export const PI = 3.14159;

export function add(a, b) {
  return a + b;
}

export function multiply(a, b) {
  return a * b;
}

// Default export
export default class Calculator {
  add(a, b) {
    return a + b;
  }

  subtract(a, b) {
    return a - b;
  }
}
File: app.js

// Import default export
import Calculator from './math.js';

// Import named exports
import { PI, add, multiply } from './math.js';

// Import with alias
import { add as mathAdd } from './math.js';

// Import all exports as a namespace
import * as MathUtils from './math.js';

const calc = new Calculator();
console.log(calc.subtract(10, 5)); // 5

console.log(add(2, 3)); // 5
console.log(mathAdd(4, 5)); // 9
console.log(MathUtils.PI); // 3.14159
console.log(MathUtils.multiply(2, 3)); // 6

🔧 Node.js இல் ES தொகுதிகளைப் பயன்படுத்த:

நீங்கள் ஒன்றைச் செய்யலாம்:

  • தொகுதி கோப்புகளுக்கு .mjs நீட்டிப்பைப் பயன்படுத்தவும்
  • உங்கள் package.json க்கு "type": "module" சேர்க்கவும்
  • --experimental-modules கொடியைப் பயன்படுத்தவும் (பழைய Node.js பதிப்புகள்)

CommonJS தொகுதி அமைப்பு (require() மற்றும் module.exports) இன்னும் Node.js இல் பரவலாகப் பயன்படுத்தப்படுகிறது. ES தொகுதிகள் மற்றும் CommonJS ஒரே திட்டத்தில் இணைந்திருக்க முடியும், ஆனால் அவை வெவ்வேறு சொற்பொருளைக் கொண்டுள்ளன.

மேம்படுத்தப்பட்ட பொருள் லிட்டரல்கள்

ES6+ பொருள் உருவாக்கத்தை மிகவும் சுருக்கமான மற்றும் வெளிப்படையானதாக ஆக்கும் பொருள் லிட்டரல்களில் பல மேம்பாடுகளை அறிமுகப்படுத்தியது.

எடுத்துக்காட்டு: மேம்படுத்தப்பட்ட பொருள் லிட்டரல்கள்

// Property shorthand
const name = 'Alice';
const age = 30;

// Instead of {name: name, age: age}
const person = { name, age };
console.log(person);

// Method shorthand
const calculator = {
  // Instead of add: function(a, b) { ... }
  add(a, b) {
    return a + b;
  },
  subtract(a, b) {
    return a - b;
  }
};
console.log(calculator.add(5, 3));

விருப்பமான சேனலிங் மற்றும் நலிஷ் கோலஸிங்

நவீன JavaScript கூடு கட்டப்பட்ட பண்புகளைப் பாதுகாப்பாக அணுகவும் வீழ்ப்பிணை மதிப்புகளை வழங்கவும் தொடரியலை அறிமுகப்படுத்துகிறது.

விருப்பமான சேனலிங் (?.)

விருப்பமான சேனலிங் சங்கிலியில் null அல்லது வரையறுக்கப்படாத மதிப்புகளைப் பற்றி கவலைப்படாமல் ஆழமாக கூடு கட்டப்பட்ட பொருள் பண்புகளை அணுக உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு: விருப்பமான சேனலிங்

function getUserCity(user) {
  return user?.address?.city;
}

const user1 = {
  name: 'Alice',
  address: { city: 'New York', country: 'USA' }
};

const user2 = {
  name: 'Bob'
};

const user3 = null;

console.log(getUserCity(user1)); // 'New York'
console.log(getUserCity(user2)); // undefined
console.log(getUserCity(user3)); // undefined

நலிஷ் கோலஸிங் (??)

நலிஷ் கோலஸிங் ஆபரேட்டர் (??) ஒரு மதிப்பு null அல்லது வரையறுக்கப்படாதபோது (ஆனால் 0 அல்லது "" போன்ற பிற பொய் மதிப்புகளுக்கு அல்ல) ஒரு இயல்புநிலை மதிப்பை வழங்குகிறது.

எடுத்துக்காட்டு: நலிஷ் கோலஸிங்

function calculatePrice(price, tax) {
  // Only uses default if tax is null or undefined
  return price + (tax ?? 0.1) * price;
}

console.log(calculatePrice(100, 0)); // 100 (correct! tax of 0 was used)
console.log(calculatePrice(100, null)); // 110 (using default)

நவீன அசிங்க்ரோனஸ் வடிவங்கள்

நவீன JavaScript அசிங்க்ரோனஸ் செயல்பாடுகளைக் கையாள சக்திவாய்ந்த வடிவங்களை வழங்குகிறது. தொடர்ச்சியான மற்றும் இணையான செயல்பாட்டை எப்போது பயன்படுத்துவது என்பதைப் புரிந்துகொள்வது உங்கள் பயன்பாட்டின் செயல்திறனைக் கணிசமாக மேம்படுத்தும்.

தொடர்ச்சியான மற்றும் இணையான செயல்பாடு:

எடுத்துக்காட்டு: தொடர்ச்சியான செயல்பாடு

// Helper function to simulate an API call
function fetchData(id) {
  return new Promise(resolve => {
    setTimeout(() => resolve(`Data for ID ${id}`), 1000);
  });
}

// Sequential execution (~3 seconds total)
async function fetchSequential() {
  console.time('sequential');
  const data1 = await fetchData(1);
  const data2 = await fetchData(2);
  const data3 = await fetchData(3);
  console.timeEnd('sequential');
  return [data1, data2, data3];
}

// Run the sequential example
fetchSequential().then(results => {
  console.log('Sequential results:', results);
});

எடுத்துக்காட்டு: இணையான செயல்பாடு

// Parallel execution (~1 second total)
async function fetchParallel() {
  console.time('parallel');
  const results = await Promise.all([
    fetchData(1),
    fetchData(2),
    fetchData(3)
  ]);
  console.timeEnd('parallel');
  return results;
}

// Run the parallel example
fetchParallel().then(results => {
  console.log('Parallel results:', results);
});

🚀 ஒவ்வொரு வடிவத்தையும் எப்போது பயன்படுத்துவது:

  • தொடர்ச்சியானது பயன்படுத்தவும்: செயல்பாடுகள் முந்தைய முடிவுகளைச் சார்ந்திருக்கும் போது
  • இணையானது பயன்படுத்தவும்: செயல்பாடுகள் சுயாதீனமாக இருக்கும் போது மற்றும் ஒரே நேரத்தில் இயக்க முடியும்
  • இணையான API அழைப்புகளைச் செய்யும் போது விகித வரம்புகளைப் பற்றி எச்சரிக்கையாக இருங்கள்
  • கட்டுப்படுத்தப்பட்ட இணை செயல்பாட்டிற்கு p-queue போன்ற நூலகங்களைப் பயன்படுத்தவும்

சுருக்கம்

ES6+ குறியீடு மேலும் வாசிக்கக்கூடிய, பராமரிக்கக்கூடிய மற்றும் வலுவானதாக மாற்றும் பல அம்சங்களை அறிமுகப்படுத்தியது:

let/const

தெளிவான சொற்பொருளுடன் தொகுதி-நோக்கமான மாறிகள்

அம்புக்குறி செயல்பாடுகள்

சுருக்கமான தொடரியல் மற்றும் சொல்லியல் this பைண்டிங்

டெம்ப்ளேட் லிட்டரல்கள்

சரம் இடைச்செருகல் மற்றும் பல-வரி சரங்கள்

டீஸ்ட்ரக்சரிங்

பொருள்கள் மற்றும் வரிசைகளிலிருந்து மதிப்புகளை எளிதாகப் பிரித்தெடுக்கவும்

ஸ்ப்ரெட்/ரெஸ்ட் ஆபரேட்டர்கள்

திறம்பட தொகுப்புகளுடன் வேலை செய்யவும்

இயல்புநிலை அளவுருக்கள்

எளிமையான செயல்பாடு வரையறைகள்

வகுப்புகள்

ஆப்ஜெக்ட்-ஓரியண்டெட் நிரலாக்கத்திற்கான சுத்தமான தொடரியல்

வாக்குறுதிகள் மற்றும் async/await

சிறந்த அசிங்க்ரோனஸ் குறியீடு மேலாண்மை

ES தொகுதிகள்

தரப்படுத்தப்பட்ட குறியீடு அமைப்பு

மேம்படுத்தப்பட்ட பொருள் லிட்டரல்கள்

மிகவும் சுருக்கமான பொருள் தொடரியல்

விருப்பமான சேனலிங் & நலிஷ் கோலஸிங்

பாதுகாப்பான சொத்து அணுகல் மற்றும் இயல்புநிலை

இந்த நவீன அம்சங்கள் தற்போதைய Node.js பதிப்புகளில் முழுமையாக ஆதரிக்கப்படுகின்றன, பொதுவான JavaScript ஆபத்துகளைத் தவிர்க்கும் போது சுத்தமான, மேலும் வெளிப்படையான குறியீட்டை எழுத உங்களை அனுமதிக்கின்றன.

பயிற்சி

❓ சரியான ES6 முக்கிய வார்த்தையை இழுத்து விடவும்.

🔤 ______ முக்கிய வார்த்தை மீண்டும் ஒதுக்கப்பட முடியாத மாறிகளை உருவாக்குகிறது.

let
✗ தவறு! "let" மீண்டும் ஒதுக்கப்படக்கூடிய மாறிகளை உருவாக்குகிறது
const
✓ சரி! "const" முக்கிய வார்த்தை மாறிகள் மீண்டும் ஒதுக்கப்பட முடியாத மாறிகளை உருவாக்குகிறது
var
✗ தவறு! "var" ES6 அல்ல, மேலும் இது மீண்டும் ஒதுக்கப்படக்கூடிய மாறிகளை உருவாக்குகிறது
static
✗ தவறு! "static" ஒரு முக்கிய வார்த்தை அல்ல, மேலும் இது JavaScript இல் மாறிகளை அறிவிக்கப் பயன்படுத்தப்படுவதில்லை